Skip to main content

Scaling Engineering Teams: How We Maintained Velocity as We Grew

Scaling an engineering team presents unique challenges. Maintaining velocity, code quality, and team morale as you grow isn't automatic – it requires intentionality and a willingness to adapt. This article outlines the key strategies we employed to scale from a team of five to over twenty engineers without sacrificing what made us effective in the first place.

The Sweet Spot: Team Size and Communication​

One of the first hurdles is determining the optimal team size. We found that teams of around 7-9 engineers were most effective. Beyond that, communication overhead began to significantly impact productivity. Smaller teams foster closer collaboration, quicker decision-making, and a stronger sense of ownership. While the ideal size is context-dependent – considering team experience and project complexity – striving for smaller, focused teams is a good starting point. A visual representation of this concept is helpful: consider a graph where communication overhead (y-axis) increases exponentially as team size (x-axis) grows.

Intentional Onboarding & Knowledge Sharing​

New team members need to quickly integrate into the existing workflow and codebase. We implemented a tiered onboarding approach:

  • Week 1: Immersion. Focus on company culture, team processes, and high-level architecture. Pair new hires with experienced engineers for shadowing and initial tasks.
  • Weeks 2-4: Targeted Contributions. Assign small, well-defined tasks that allow new engineers to contribute to the codebase and learn by doing. Regular check-ins and code reviews are critical.
  • Months 2-3: Increased Ownership. Gradually increase the scope and complexity of assigned tasks, encouraging new engineers to take ownership of specific features or components.

Crucially, we emphasized documentation as they go. Encouraging engineers to document their work while they’re doing it, rather than as an afterthought, significantly improved knowledge sharing and reduced onboarding friction. We also incorporated direct customer interaction into the onboarding process. Having new hires listen to customer support calls or participate in user interviews provided valuable context and helped them understand the why behind the code they were writing.

Refining Processes – Don't Just Add More Meetings​

As teams grow, existing processes often become strained. Resist the urge to simply add more meetings. Instead, focus on refining existing processes to improve efficiency and clarity. Here’s where we focused our efforts:

  • Scrum/Agile: Maintaining short sprints and daily stand-ups ensured everyone stayed aligned. However, we regularly reviewed our sprint ceremonies to identify and eliminate inefficiencies.
  • Code Review: A robust code review process is essential for maintaining code quality. As teams grew, we implemented a “review pyramid.” Daily, 15-minute code reviews focused on specific modules, followed by a more in-depth review from a senior engineer before merging. This ensured timely feedback and prevented technical debt from accumulating.
  • Definition of Done (DoD): As teams grew, the need for a clear Definition of Done became even more crucial to prevent ambiguity and ensure consistent quality. We explicitly defined what constituted "done" for each task, including code review, testing, documentation, and deployment.
  • Automated Testing: Investing in automated testing (unit, integration, and end-to-end) freed up engineers from manual testing and reduced the risk of regressions.

Accountability & Ownership - The Foundation of Scalability​

Clear accountability and ownership are vital for maintaining productivity as teams grow. We focused on these key practices:

  • Clear Roles & Responsibilities: Each engineer had clearly defined roles and responsibilities, minimizing confusion and overlap.
  • Feature Ownership: We encouraged engineers to take end-to-end ownership of specific features or components, from design to implementation to maintenance.
  • Regular Feedback Loops: Frequent one-on-one meetings and performance reviews provided opportunities for feedback, coaching, and growth. We also implemented 360-degree feedback to gather input from peers and stakeholders.

The Importance of Team-Oriented Individuals​

Technical skills are important, but they’re not enough. We prioritized hiring engineers who were collaborative, communicative, and passionate about learning. During the interview process, we used behavioral questions to assess these soft skills. For example, “Tell me about a time you had to work with a difficult teammate. How did you handle the situation?” We also looked for candidates who demonstrated a growth mindset and a willingness to embrace new technologies and challenges.

Tools That Helped Us Scale​

Several tools proved invaluable in supporting our growth:

  • Jira: For project management and issue tracking.
  • Slack: For real-time communication and collaboration.
  • GitHub: For version control and code collaboration.
  • CircleCI: For continuous integration and continuous delivery (CI/CD).
  • Datadog: For monitoring and observability.

Facing Challenges & Adapting​

Scaling isn't without its challenges. We encountered issues with communication breakdowns, conflicting priorities, and technical debt. The key was to be proactive, address problems quickly, and be willing to adapt our processes as needed. Regularly soliciting feedback from the team and conducting retrospectives helped us identify areas for improvement and stay on track.

Conclusion​

Scaling an engineering team requires more than just adding more engineers. It demands intentionality, a focus on clear communication, well-defined processes, and a commitment to fostering a collaborative and supportive culture. By prioritizing these principles, we were able to scale our team without sacrificing the velocity, quality, and innovation that made us successful in the first place.